Thread: [Warning] comparison is always false due to limited range of data type

Hi there!

Really, really strange, I have no clue why I get two warnings. Look at the code yourself, I splitted the lines to see where exactly the compiler (gcc) shouts:

Code:

int func(char *buf)
{
...
	if(buf[i] == 0xaf 
	&& buf[i+1] == 0x00)
		if(buf[i+2] == 0x09 
		&& buf[i+3] == 0x00 
		&& buf[i+4] == 0x01 
		&& buf[i+5] == 0x00 
		&& buf[i+6] == 0xb0
		&& buf[i+7] == 0x00 
		&& buf[i+38] == 0x01 
		&& buf[i+39] == 0x00)
...
}

Only these two lines get the warning! I mean... does the compiler know the values under race conditions already before?

Are you sure that these are the two lines??
An Introduction to GCC - Portability of signed and unsigned types

I have read this internet page before posting.

And yes, the compiler writes this error for line 140 and 146. It's these two lines that I highlighted.

I wonder so much because I use the same method in the same program also, working! The problem is, the code is REALLY not working. I manually check the array "buf", and it contains the data where it should trigger, but it doesn't trigger!

Other data does trigger though, like:

Code:

			if(buf[i] == 0x78 && buf[i+1] == 0x00)
				if(buf[i+17] == 0x00 && buf[i+18] == 0x00 && buf[i+19] == 0x00 && buf[i+20] == 0x00 && buf[i+21] == 0x00
				 && buf[i+22] == 0x00 && buf[i+23] == 0x00 && buf[i+24] == 0x00 && buf[i+25] == 0x00 && buf[i+26] == 0x00
				  && buf[i+27] == 0x00 && buf[i+28] == 0x00 && buf[i+29] == 0x00 && buf[i+30] == 0x00 && buf[i+31] == 0x00
				   && buf[i+32] == 0x00 && buf[i+33] == 0x00 && buf[i+34] == 0x00 && buf[i+35] == 0x00 && buf[i+36] == 0x00
				    && buf[i+37] == 0x00 && buf[i+38] == 0x00 && buf[i+39] == 0x00 && buf[i+40] == 0x00 && buf[i+41] == 0x00
				     && buf[i+42] == 0x00 && buf[i+43] == 0x00 && buf[i+44] == 0x00 && buf[i+45] == 0x00 && buf[i+46] == 0x00)

and

Code:

			if(buf[i] == 0x2c && buf[i+1] == 0x02)
				if(buf[i+19] == 0x00 && buf[i+20] == 0x00 && buf[i+21] == 0x00 && buf[i+22] == 0x00 && buf[i+23] == 0x00
				 && buf[i+24] == 0x00 && buf[i+25] == 0x00 && buf[i+26] == 0x00 && buf[i+31] == 0x00 && buf[i+32] == 0x00
				  && buf[i+33] == 0x00 && buf[i+34] == 0x00 && buf[i+35] == 0x00 && buf[i+36] == 0x00 && buf[i+37] == 0x00
				   && buf[i+38] == 0x00 && buf[i+39] == 0x00 && buf[i+40] == 0x00 && buf[i+41] == 0x00 && buf[i+42] == 0x00)

Okay I see that the warnings occur before comparing a signed char with 0xaf and 0xb0.

I always thought, when I write 0xFF or \xFF, it doesn't matter if a number is treated as signed or unsigned because it is just a byte comparision (0xFF is always 0xFF, no matter if treated unsigned or signed, and there is no thing as -0xb0 am I right?)

So if this is obviously the problem, how can I compare it correctly without using buf[i] == -1 instead of buf[i] == 0xFF and without casting to every compare? I don't want to calculate all hex bytes into decimal numbers just for comparision. The buffer itself also must stay signed.

You can make sure the buffer is declared unsigned, as in

Code:

int func(unsigned char *buf)

I want to avoid memcmp because the locations I want to check are random and not in a row. (Sometimes I want to check byte 1,2,3,4 but most often I want to check 1,2,9,10,23,24,25,26 which would mean also 3 times memcmp).

Salem, nonoob, I wanted to avoid your methods.

without casting to every compare? I don't want to calculate all hex bytes into decimal numbers just for comparision. The buffer itself also must stay signed.

Does that mean there is no other option?

Originally Posted by Salem

> The buffer itself also must stay signed.
Why?

Because the code is old and long where I do many other things. Working with data as well as working with ascii chars and I don't want to check all the working code again

Originally Posted by Salem

unsigned char *ubuf = (unsigned char *)buf;

That's exactly what I needed, thanks!